np.sqrt(24326)

%load_ext pretty_jupyter

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.neighbors import NearestNeighbors
from sklearn.metrics import confusion_matrix

# KNeighborsClassifier é um modelo de classificação
#  baseado no algoritmo K-Nearest Neighbors (KNN) da biblioteca scikit-learn.
from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor

# confusion_matrix, accuracy_score, precision_score, 
#   recall_score, f1_score: Funções do scikit-learn 
#   para calcular métricas de desempenho.
from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import BaggingClassifier
import time
from tqdm import tqdm
from sklearn.base import clone

# Usado no Modelo 2
from scipy.sparse import csr_matrix
from sklearn.neighbors import NearestNeighbors
from sklearn.metrics import pairwise_distances
from sklearn.metrics.pairwise import pairwise_kernels

import joblib

# Dados de treino
knn_filmes_treino = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/knn_filmes_treino.pickle", compression='gzip')

# Dados de teste
knn_filmes_teste = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.3_Datasets_Transformação_parte_3/knn_filmes_teste.pickle", compression='gzip')

# Olhar tabela de treino para modelagem 1: Filmes
knn_filmes_treino

# Olhar tabela de teste para modelagem 1: Filmes
knn_filmes_teste

# Definir um ponto de corte
#corte = 3.5  # ponto de corte

# Transformar em rótulos binários
#knn_filmes_treino1 = knn_filmes_treino.applymap(lambda x: 1 if x > corte else 0)

#knn_filmes_treino1

# Definir um ponto de corte
#corte = 3.5  # ponto de corte

# Transformar em rótulos binários
#knn_filmes_teste1 = knn_filmes_teste.applymap(lambda x: 1 if x > corte else 0)

# Usando KNeighborRegressor() ----------
# X_train são os índices dos usuários no DataFrame train convertidos para um array 2D.
X_train_filmes = knn_filmes_treino.index.values.reshape(-1, 1)
#y_train são os valores dos filmes que os usuários assistiram no DataFrame train
y_train_filmes = knn_filmes_treino.values

# Usando KNeighborsClassifier() ----------
# X_train são os índices dos usuários no DataFrame train convertidos para um array 2D.
#X_train_filmes1 = knn_filmes_treino1.index.values.reshape(-1, 1)
# y_train são os valores dos filmes que os usuários assistiram no DataFrame train
#y_train_filmes1 = knn_filmes_treino1.values

X_train_filmes

y_train_filmes 

# Usando KNeighborRegressor() ----------
# Separar variáveis de entrada (X) e saída (y) para o teste
X_test_filmes = knn_filmes_teste.index.values.reshape(-1, 1)
y_test_filmes = knn_filmes_teste.values

# Usando KNeighborsClassifier() ----------
# Separar variáveis de entrada (X) e saída (y) para o teste
#X_test_filmes1 = knn_filmes_teste1.index.values.reshape(-1, 1)
#y_test_filmes1 = knn_filmes_teste1.values

X_test_filmes

y_test_filmes

# Usando KNeighborRegressor() ----------
# Treinar o modelo KNN com os dados de treinamento (X_train e y_train)
# Usando KNeighborsRegressor()
modelo_filmes = KNeighborsRegressor(n_neighbors=155)
modelo_filmes.fit(X_train_filmes, y_train_filmes)


# Usando KNeighborsClassifier()-------
#modelo_filmes1 = KNeighborsClassifier(n_neighbors=47)
#modelo_filmes1.fit(X_train_filmes1, y_train_filmes1)

# SALVAR O MODELO
# Usando KNeighborsClassifier()-------

# Salvar modelo treinado (k=9)
#joblib.dump(modelo_filmes1,'C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/5.Modelagem_KNN/KNN_Classificacao_k_9/modelo_filmes1_Classificacao_k_9.joblib')

# Salvar modelo treinado (k=47)
#joblib.dump(modelo_filmes1,'C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/5.Modelagem_KNN/KNN_Classificacao_k_47/modelo_filmes1_Classificacao_k_47.joblib')

# Usando KNeighborRegressor() ----------
# Usa o modelo treinado para fazer previsões (y_pred) para os dados de teste (X_test).
y_pred_filmes = modelo_filmes.predict(X_test_filmes)

# Usando KNeighborsClassifier()-------
# Usa o modelo treinado para fazer previsões (y_pred) para os dados de teste (X_test).
#y_pred_filmes1 = modelo_filmes1.predict(X_test_filmes1)

# SALVAR A TABELA
# Usando KNeighborsClassifier()-------

# Salvar previsão do modelo (k=9)
#joblib.dump(y_pred_filmes1, 'C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/5.Modelagem_KNN/KNN_Classificacao_k_9/ y_pred_filmes1_Classificacao_k_9.joblib')

# Salvar previsão do modelo (k=47)
#joblib.dump(y_pred_filmes1, 'C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/5.Modelagem_KNN/KNN_Classificacao_k_47/ y_pred_filmes1_Classificacao_k_47.joblib')

y_pred_filmes 

# Verificar as dimensões (linhas, colunas)
knn_filmes_treino.shape

# Verificar as dimensões (linhas, colunas)
y_pred_filmes.shape

# Verificar as dimensões (linhas, colunas)
knn_filmes_teste.shape

# Converte as previsões (y_pred) em um DataFrame (pred_df)
#  com as mesmas colunas do DataFrame train e o índice do DataFrame test.
#
# Usando KNeighborRegressor() ----------
# Exibe as recomendações de filmes para os usuários no conjunto de teste
df_pred_filmes = pd.DataFrame(y_pred_filmes, columns=knn_filmes_treino.columns, index=knn_filmes_teste.index)
print("Recomendações de filmes para o conjunto de teste:")
df_pred_filmes 

# Usando KNeighborsClassifier()-------
#df_pred_filmes1 = pd.DataFrame(y_pred_filmes1, columns=knn_filmes_treino1.columns, index=knn_filmes_teste1.index)
#print("Recomendações de filmes para o conjunto de teste:")
#df_pred_filmes 

# SALVAR A TABELA
# Usando KNeighborsClassifier()-------

# Salvar as previsões convertidas em um DataFrame (k=9)
#df_pred_filmes1.to_pickle('C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/5.Modelagem_KNN/KNN_Classificacao_k_9/ df_pred_filmes1_Classificacao_k_9.pickle', compression='gzip')

# Salvar as previsões convertidas em um DataFrame (k=47)
#df_pred_filmes1.to_pickle('C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/5.Modelagem_KNN/KNN_Classificacao_k_47/ df_pred_filmes1_Classificacao_k_47.pickle', compression='gzip')

# Contando valores diferentes de zero em toda a tabela
total_valores_nao_zero = (df_pred_filmes  != 0).sum().sum()
print(f"Total de valores não zero na tabela: {total_valores_nao_zero}")

# Contar valores diferentes de zero em cada coluna
count_sem_zero = (df_pred_filmes != 0).sum()

# Calcular a proporção desses valores em relação ao total de linhas
proporcao = count_sem_zero / len(df_pred_filmes)

# Criar um DataFrame de resumo
summary_df = pd.DataFrame({
    'Valores_Diferentes_de_zero': count_sem_zero,
    'Proporcao': proporcao
})

print("Os 10 filmes mais recomendados:")
summary_df.sort_values(by='Valores_Diferentes_de_zero', ascending=False).head(10)

print("Os 10 filmes menos recomendados:")
summary_df.sort_values(by='Valores_Diferentes_de_zero', ascending=True).head(10)

n_recomendacoes =5

# Função para encontrar os top N filmes recomendados para um usuário
def top_recomendacoes(row, n) -> list:
    ''' Função que encontra as melhores recomendações para cada userId
    Args:
      - row = linha do DataFrame. 
              Cada linha representa as recomendações de filme para cada userId.
      - n = número de filmes a serem recomendados 

    Return:
      - Retorna uma lista com os "n" valores mais altos em cada. 
       Ou seja, retorna com as "n" recomendações de filmes.      
    '''
    # Selecionar e retornar os "n" valores mais altos de cada linha
    return row.nlargest(n).index.tolist()

    #OBS: .index(): Obtemos os nomes dos filmes, ao invés dos valores.
    #     .tolist(): Criamos uma lista com os nomes dos filmes 

# Usando KNeighborRegressor() ----------
# Aplicar a função a cada linha do DataFrame de previsões
recomendacoes = df_pred_filmes.apply(top_recomendacoes, n=n_recomendacoes, axis=1) 

# OBS: apply(... axis=1) -> Aplicar em cada linha
#      n = número de recomendações

# Usando KNeighborsClassifier()-------
# Aplicar a função a cada linha do DataFrame de previsões
#recomendacoes1 = df_pred_filmes1.apply(top_recomendacoes, n=n_recomendacoes, axis=1) 

recomendacoes

# Usando KNeighborRegressor() ----------
# Cria um DataFrame para armazenar as recomendações
df_recomendacoes = pd.DataFrame(recomendacoes.tolist(), index=recomendacoes.index, columns=[f"recomendação_{i+1}" for i in range(n_recomendacoes)])

# Transformar o userId em coluna
df_recomendacoes = df_recomendacoes.reset_index()
df_recomendacoes

# Usando KNeighborsClassifier()-------
# Cria um DataFrame para armazenar as recomendações
#df_recomendacoes1 = pd.DataFrame(recomendacoes1.tolist(), index=recomendacoes1.index, columns=[f"recomendação_{i+1}" for i in range(n_recomendacoes)])

# Transformar o userId em coluna
#df_recomendacoes1 = df_recomendacoes1.reset_index()

df_recomendacoes.isna().sum()

def assistiu_ou_nao(row, df_teste):
    # Obtém as recomendações para o usuário atual
    recomendacoes = row.drop('userId').values
    
    # Verifica se algum dos filmes recomendados está no df_teste e foi assistido (rating diferente de 0)
    for filme in recomendacoes:
        if filme in df_teste.columns and df_teste.loc[row['userId'], filme] != 0:
            return 1
        elif filme not in df_teste.columns:
            return 2 #Se um filme for recomendado mas não tiver nnos dados de teste
        else:
            return 0 #Se nenhum filme recomendado foi assistido, retorna 0
      

# Usando KNeighborRegressor() ----------
# Aplica a função a cada linha do DataFrame de recomendações para criar a coluna dummy
df_recomendacoes['assistiu_recomendacao'] = df_recomendacoes.apply(assistiu_ou_nao, df_teste=knn_filmes_teste, axis=1)

# Exibe o DataFrame final com a coluna dummy
df_recomendacoes

# Usando KNeighborsClassifier()-------
#df_recomendacoes1['assistiu_recomendacao'] = df_recomendacoes1.apply(assistiu_ou_nao, df_teste=knn_filmes_teste1, axis=1)
#df_recomendacoes1

# Usando KNeighborRegressor() ----------
# Resultado quando K=47
df_recomendacoes['assistiu_recomendacao'].value_counts()

# Garantir que ambos os DataFrames tenham as mesmas colunas (filmes)
common_columns = knn_filmes_treino.columns.intersection(knn_filmes_teste.columns)
knn_filmes_treino = knn_filmes_treino[common_columns]
knn_filmes_teste = knn_filmes_teste[common_columns]

# Função para converter as matrizes em matrizes esparsas
def create_sparse_matrix(matrix):
    return csr_matrix(matrix)

# Preparar os dados
features_matrix_treino = create_sparse_matrix(knn_filmes_treino.values)
features_matrix_teste = create_sparse_matrix(knn_filmes_teste.values)

features_matrix_treino 

# Função para criar e treinar o modelo Nearest Neighbors
def train_model(features_matrix, n_neighbors):
    model = NearestNeighbors(n_neighbors=n_neighbors, metric='euclidean', algorithm='ball_tree')
    model.fit(features_matrix)
    return model

# Criar e treinar o modelo
model = train_model(features_matrix_treino, n_neighbors=155)
model

# Função para obter recomendações para um usuário específico
def get_recommendations(model, knn_filmes_treino, features_matrix_teste, query_index, n_neighbors):
    distances, indices = model.kneighbors(features_matrix_teste[query_index], n_neighbors=n_neighbors+1)  # +1 para incluir o próprio filme
    recommendations = [knn_filmes_treino.columns[indices.flatten()[i+1]] for i in range(n_neighbors)]  # Excluir o próprio filme (índice 0)
    return recommendations

# Função principal para recomendação de filmes para todos os usuários nos dados de teste
def recommend_movies(knn_filmes_treino, knn_filmes_teste, model, features_matrix_teste, n_neighbors=150):
    # Inicializar uma lista para armazenar as recomendações
    recommendations_list = []

    # Para cada usuário nos dados de teste, encontrar filmes similares usando kneighbors
    for query_index in range(features_matrix_teste.shape[0]):
        recommendations = get_recommendations(model, knn_filmes_treino, features_matrix_teste, query_index, n_neighbors)
        recommendations_list.append({
            'userId': knn_filmes_teste.index[query_index],
            'Recommendation_1': recommendations[0],
            'Recommendation_2': recommendations[1],
            'Recommendation_3': recommendations[2],
            'Recommendation_4': recommendations[3],
            'Recommendation_5': recommendations[4]
        })

    # Converter a lista de recomendações em DataFrame
    recommendations_df = pd.DataFrame(recommendations_list)
    return recommendations_df

# Garantir que os índices são 'userId' e obter recomendações
recommendations = recommend_movies(knn_filmes_treino, knn_filmes_teste, model, features_matrix_teste, n_neighbors=150)

recommendations

def assistiu_ou_nao(row, df_teste):
    # Obtém as recomendações para o usuário atual
    recomendacoes = row.drop('userId').values
    
    # Verifica se algum dos filmes recomendados está no df_teste e foi assistido (rating diferente de 0)
    for filme in recomendacoes:
        if filme in df_teste.columns and df_teste.loc[row['userId'], filme] != 0:
            return 1
    return 0 #Se nenhum filme recomendado foi assistido, retorna 0

# Aplica a função a cada linha do DataFrame de recomendações para criar a coluna dummy
recommendations['assistiu_recomendacao'] = recommendations.apply(assistiu_ou_nao, df_teste=knn_filmes_teste, axis=1)

# Exibe o DataFrame final com a coluna dummy
recommendations

# n_neighbors=150
recommendations['assistiu_recomendacao'].value_counts()